/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package db;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Tuple;

/**
 *
 * @author Salm
 */
public class MultiRedisAdapter /*implements Redis*/ {
//
//    private final Redis[] redisInsts;
//
//    public MultiRedisAdapter(Redis[] redisInsts) {
//        this.redisInsts = redisInsts;
//    }
//
//    @Override
//    public String set(RedisKey key, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.set(key, value);
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle set request");
//    }
//
//    @Override
//    public String get(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.get(key);
//                
//                if (!isEmpty(ret))
//                    return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle get request");
//    }
//
//    @Override
//    public Long del(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                redisInst.del(key);
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return 1L;
//    }
//
//    @Override
//    public Boolean exists(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Boolean ret = redisInst.exists(key);
//                
//                if (!isEmpty(ret))
//                    return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return false;
//    }
//
//    @Override
//    public String type(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.type(key);
//
//                if (!isEmpty(ret))
//                    return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle type request");
//    }
//
//    @Override
//    public Long expire(RedisKey key, int seconds) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                redisInst.expire(key, seconds);
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return 1L;
//    }
//
//    @Override
//    public Long expireAt(RedisKey key, long unixTime) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                redisInst.expireAt(key, unixTime);
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return 1L;
//    }
//
//    @Override
//    public Long ttl(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.ttl(key);
//                
//                if (ret != null)
//                    return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle ttl request");
//    }
//
//    @Override
//    @Deprecated
//    public String getSet(RedisKey key, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.getSet(key, value);
//                if (!isEmpty(ret))
//                    return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle getSet request");
//    }
//
//    @Override
//    public Long setnx(RedisKey key, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.setnx(key, value);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle setnx request");
//    }
//
//    @Override
//    public String setex(RedisKey key, int seconds, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.setex(key, seconds, value);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle setex request");
//    }
//
//    @Override
//    public Long decrBy(RedisKey key, long integer) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.decrBy(key, integer);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle decrBy request");
//    }
//
//    @Override
//    public Long decr(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.decr(key);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle decr request");
//    }
//
//    @Override
//    public Long incrBy(RedisKey key, long integer) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.incrBy(key, integer);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle incrBy request");
//    }
//
//    @Override
//    public Long incr(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.incr(key);
//                return ret;
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle incr request");
//    }
//
//    @Override
//    public Long append(RedisKey key, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.append(key, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle append request");
//    }
//
//    @Override
//    public Long hset(RedisKey key, String field, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hset(key, field, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hset request");
//    }
//
//    @Override
//    public String hset(RedisKey key, Map<String, String> hash) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.hset(key, hash);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hset request");
//    }
//
//    @Override
//    public String hget(RedisKey key, String field) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.hget(key, field);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hget request");
//    }
//
//    @Override
//    public Long hsetnx(RedisKey key, String field, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hsetnx(key, field, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hsetnx request");
//    }
//
//    @Override
//    public String hmset(RedisKey key, Map<String, String> hash) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.hmset(key, hash);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hmset request");
//    }
//
//    @Override
//    public List<String> hmget(RedisKey key, String... fields) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.hmget(key, fields);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hmget request");
//    }
//
//    @Override
//    public Long hincrBy(RedisKey key, String field, long value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hincrBy(key, field, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hincrBy request");
//    }
//
//    @Override
//    public Long hincrby(RedisKey key, String field, long value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hincrby(key, field, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hincrby request");
//    }
//
//    @Override
//    public Boolean hexists(RedisKey key, String field) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Boolean ret = redisInst.hexists(key, field);
//                if (ret != null && ret)
//                {
//                    return ret;
//                }
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return false;
//    }
//
//    @Override
//    public Long hdel(RedisKey key, String... field) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hdel(key, field);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hdel request");
//    }
//
//    @Override
//    public Long hlen(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.hlen(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hlen request");
//    }
//
//    @Override
//    public Set<String> hkeys(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.hkeys(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hkeys request");
//    }
//
//    @Override
//    public List<String> hvals(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.hvals(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hvals request");
//    }
//
//    @Override
//    public Map<String, String> hmget(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Map<String, String> ret = redisInst.hmget(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hmget request");
//    }
//
//    @Override
//    public Long rpush(RedisKey key, String... string) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.rpush(key, string);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle rpush request");
//    }
//
//    @Override
//    public Long lpush(RedisKey key, String... string) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.lpush(key, string);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lpush request");
//    }
//
//    @Override
//    public Long llen(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.llen(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle llen request");
//    }
//
//    @Override
//    public List<String> lrange(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.lrange(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lrange request");
//    }
//
//    @Override
//    public String ltrim(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.ltrim(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle ltrim request");
//    }
//
//    @Override
//    public String lindex(RedisKey key, long index) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.lindex(key, index);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lindex request");
//    }
//
//    @Override
//    public String lset(RedisKey key, long index, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.lset(key, index, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lset request");
//    }
//
//    @Override
//    public Long lrem(RedisKey key, long count, String value) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.lrem(key, count, value);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lrem request");
//    }
//
//    @Override
//    public String lpop(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.lpop(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lpop request");
//    }
//
//    @Override
//    public String rpop(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.rpop(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle rpop request");
//    }
//
//    @Override
//    public Long sadd(RedisKey key, String... member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.sadd(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sadd request");
//    }
//
//    @Override
//    public Set<String> smembers(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.smembers(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle smembers request");
//    }
//
//    @Override
//    public Long srem(RedisKey key, String... member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.srem(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle srem request");
//    }
//
//    @Override
//    public String spop(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.spop(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle spop request");
//    }
//
//    @Override
//    public Long scard(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.scard(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle scard request");
//    }
//
//    @Override
//    public Boolean sismember(RedisKey key, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Boolean ret = redisInst.sismember(key, member);
//                if (ret != null && ret)
//                {
//                    return ret;
//                }
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        return false;
//    }
//
//    @Override
//    public String srandmember(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                String ret = redisInst.srandmember(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle srandmember request");
//    }
//
//    @Override
//    public Set<String> sdiff(RedisKey key, RedisKey... keys) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.sdiff(key, keys);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sdiff request");
//    }
//
//    @Override
//    public Set<String> sinter(RedisKey key, RedisKey... keys) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.sinter(key, keys);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sinter request");
//    }
//
//    @Override
//    public Long zadd(RedisKey key, double score, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zadd(key, score, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zadd request");
//    }
//
//    @Override
//    public Long zadd(RedisKey key, Map<Double, String> scoreMembers) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zadd(key, scoreMembers);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zadd request");
//    }
//
//    @Override
//    public Set<String> zrange(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrange(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrange request");
//    }
//
//    @Override
//    public Long zrem(RedisKey key, String... member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zrem(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrem request");
//    }
//
//    @Override
//    public Double zincrby(RedisKey key, double score, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Double ret = redisInst.zincrby(key, score, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zincrby request");
//    }
//
//    @Override
//    public Long zrank(RedisKey key, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zrank(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrank request");
//    }
//
//    @Override
//    public Long zrevrank(RedisKey key, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zrevrank(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrank request");
//    }
//
//    @Override
//    public Set<String> zrevrange(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrevrange(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrange request");
//    }
//
//    @Override
//    public Set<Tuple> zrangeWithScores(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrangeWithScores(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrevrangeWithScores(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrevrangeWithScores(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeWithScores request");
//    }
//
//    @Override
//    public Long zcard(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zcard(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zcard request");
//    }
//
//    @Override
//    public Double zscore(RedisKey key, String member) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Double ret = redisInst.zscore(key, member);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zscore request");
//    }
//
//    @Override
//    public List<String> sort(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.sort(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sort request");
//    }
//
//    @Override
//    public List<String> sort(RedisKey key, SortingParams sortingParameters) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.sort(key, sortingParameters);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sort request");
//    }
//
//    @Override
//    public Long zcount(RedisKey key, double min, double max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zcount(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zcount request");
//    }
//
//    @Override
//    public Long zcount(RedisKey key, String min, String max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zcount(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zcount request");
//    }
//
//    @Override
//    public Set<String> zrangeByScore(RedisKey key, double min, double max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrangeByScore(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrangeByScore(RedisKey key, String min, String max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrangeByScore(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrevrangeByScore(RedisKey key, double max, double min) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrevrangeByScore(key, max, min);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrevrangeByScore(RedisKey key, double max, double min, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrevrangeByScore(key, max, min, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrangeByScore(RedisKey key, double min, double max, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrangeByScore(key, min, max, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrevrangeByScore(RedisKey key, String max, String min) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrevrangeByScore(key, max, min);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScore request");
//    }
//
//    @Override
//    public Set<String> zrangeByScore(RedisKey key, String min, String max, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrangeByScore(key, min, max, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScore request");
//    }
//
//    @Override
//    public Set<Tuple> zrangeByScoreWithScores(RedisKey key, double min, double max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrangeByScoreWithScores(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrevrangeByScoreWithScores(RedisKey key, double max, double min) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrevrangeByScoreWithScores(key, max, min);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrangeByScoreWithScores(RedisKey key, double min, double max, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrangeByScoreWithScores(key, min, max, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<String> zrevrangeByScore(RedisKey key, String max, String min, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.zrevrangeByScore(key, max, min, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScore request");
//    }
//
//    @Override
//    public Set<Tuple> zrangeByScoreWithScores(RedisKey key, String min, String max) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrangeByScoreWithScores(key, min, max);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrevrangeByScoreWithScores(RedisKey key, String max, String min) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrevrangeByScoreWithScores(key, max, min);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrangeByScoreWithScores(RedisKey key, String min, String max, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrangeByScoreWithScores(key, min, max, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrevrangeByScoreWithScores(RedisKey key, double max, double min, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrevrangeByScoreWithScores(key, max, min, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Set<Tuple> zrevrangeByScoreWithScores(RedisKey key, String max, String min, int offset, int count) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<Tuple> ret = redisInst.zrevrangeByScoreWithScores(key, max, min, offset, count);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zrevrangeByScoreWithScores request");
//    }
//
//    @Override
//    public Long zremrangeByRank(RedisKey key, long start, long end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zremrangeByRank(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zremrangeByRank request");
//    }
//
//    @Override
//    public Long zremrangeByScore(RedisKey key, double start, double end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zremrangeByScore(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zremrangeByScore request");
//    }
//
//    @Override
//    public Long zremrangeByScore(RedisKey key, String start, String end) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.zremrangeByScore(key, start, end);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle zremrangeByScore request");
//    }
//
//    @Override
//    public Long lpushx(RedisKey key, String string) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.lpushx(key, string);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lpushx request");
//    }
//
//    @Override
//    public Long rpushx(RedisKey key, String string) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.rpushx(key, string);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle rpushx request");
//    }
//
//    @Override
//    public Set<String> keys(String patt) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Set<String> ret = redisInst.keys(patt);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle keys request");
//    }
//
//    @Override
//    public Long sndiff(RedisKey key, Set<String> vals) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.sndiff(key, vals);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle sndiff request");
//    }
//
//    @Override
//    public List<String> lgetall(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                List<String> ret = redisInst.lgetall(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lgetall request");
//    }
//
//    @Override
//    public Map<String, String> hgetall(RedisKey key) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Map<String, String> ret = redisInst.hgetall(key);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle hgetall request");
//    }
//
//    @Override
//    public Long lappend(RedisKey key, String... string) {
//        for (Redis redisInst : redisInsts) {
//            try {
//                Long ret = redisInst.lappend(key, string);
//
//                return ret;
//
//            } catch (Exception ex) {
//                //try next
//            }
//        }
//        throw new IllegalStateException("No redis instance can handle lappend request");
//    }
//    
//    private boolean isEmpty(String s)
//    {
//        return s != null && s.length() <= 0;
//    }
//    
//    private boolean isEmpty(Collection c)
//    {
//        return c != null && c.size() <= 0;
//    }
//    
//    private boolean isEmpty(Map m)
//    {
//        return m != null && m.size() <= 0;
//    }
//    
//    private boolean isEmpty(Boolean b)
//    {
//        return b != null && !b;
//    }
//
//    @Override
//    public Long incrENX(RedisKey key, int expireSecs) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Long saddENX(RedisKey key, int expireSecs, String mem) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Long hincrbyENX(RedisKey key, String field, Number by, int expireSecs) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Map<RedisKey, Boolean> mexists(Collection<RedisKey> keys) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Map<RedisKey, Map<String, String>> mhgetall(Collection<RedisKey> keys) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Long hsetENX(RedisKey key, String field, String vals, int expireSecs) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
//
//    @Override
//    public Map<String, Boolean> msismember(RedisKey key, Collection<String> mem) {
//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
//    }
}
